module ApplicationCable
          
        
      
        

          

            

            

              class Connection < ActionCable::Connection::Base
          
        
      
        

          

            

            

                identified_by :current_user
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                def connect
          
        
      
        

          

            

            

                  set_current_user || reject_unauthorized_connection
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                private
          
        
      
        

          

            

            

                  def set_current_user
          
        
      
        

          

            

            

                    if session = Session.find_by(id: cookies.signed[:session_id])
          
        
      
        

          

            

            

                      self.current_user = session.user
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class BrandComplianceChannel < ApplicationCable::Channel
          
        
      
        

          

            

            

              def subscribed
          
        
      
        

          

            

            

                if brand = find_brand
          
        
      
        

          

            

            

                  # Subscribe to brand-specific compliance updates
          
        
      
        

          

            

            

                  stream_from "brand_compliance_#{brand.id}"
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  # Subscribe to session-specific updates if session_id provided
          
        
      
        

          

            

            

                  if params[:session_id].present?
          
        
      
        

          

            

            

                    stream_from "compliance_session_#{params[:session_id]}"
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  # Send initial connection confirmation
          
        
      
        

          

            

            

                  transmit(
          
        
      
        

          

            

            

                    event: "subscription_confirmed",
          
        
      
        

          

            

            

                    brand_id: brand.id,
          
        
      
        

          

            

            

                    session_id: params[:session_id]
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  reject
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def unsubscribed
          
        
      
        

          

            

            

                # Cleanup any ongoing compliance checks for this session
          
        
      
        

          

            

            

                if params[:session_id].present?
          
        
      
        

          

            

            

                  cancel_session_jobs(params[:session_id])
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # Client can request compliance check
          
        
      
        

          

            

            

              def check_compliance(data)
          
        
      
        

          

            

            

                brand = find_brand
          
        
      
        

          

            

            

                return unless brand && authorized_to_check?(brand)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                content = data["content"]
          
        
      
        

          

            

            

                content_type = data["content_type"] || "general"
          
        
      
        

          

            

            

                options = build_check_options(data)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # Validate input
          
        
      
        

          

            

            

                if content.blank?
          
        
      
        

          

            

            

                  transmit_error("Content cannot be blank")
          
        
      
        

          

            

            

                  return
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                # Start compliance check
          
        
      
        

          

            

            

                if data["async"] == false
          
        
      
        

          

            

            

                  # Synchronous check for small content
          
        
      
        

          

            

            

                  perform_sync_check(brand, content, content_type, options)
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  # Asynchronous check for larger content
          
        
      
        

          

            

            

                  perform_async_check(brand, content, content_type, options)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # Client can request specific aspect validation
          
        
      
        

          

            

            

              def validate_aspect(data)
          
        
      
        

          

            

            

                brand = find_brand
          
        
      
        

          

            

            

                return unless brand && authorized_to_check?(brand)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                aspect = data["aspect"]&.to_sym
          
        
      
        

          

            

            

                content = data["content"]
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                unless %i[tone sentiment readability brand_voice colors typography].include?(aspect)
          
        
      
        

          

            

            

                  transmit_error("Invalid aspect: #{aspect}")
          
        
      
        

          

            

            

                  return
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                service = Branding::ComplianceServiceV2.new(brand, content, "general")
          
        
      
        

          

            

            

                result = service.check_specific_aspects([aspect])
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                transmit(
          
        
      
        

          

            

            

                  event: "aspect_validated",
          
        
      
        

          

            

            

                  aspect: aspect,
          
        
      
        

          

            

            

                  result: result[aspect]
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              rescue StandardError => e
          
        
      
        

          

            

            

                transmit_error("Validation failed: #{e.message}")
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # Client can request fix preview
          
        
      
        

          

            

            

              def preview_fix(data)
          
        
      
        

          

            

            

                brand = find_brand
          
        
      
        

          

            

            

                return unless brand && authorized_to_check?(brand)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                violation_id = data["violation_id"]
          
        
      
        

          

            

            

                content = data["content"]
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Find the violation in the current session
          
        
      
        

          

            

            

                violation = find_session_violation(violation_id)
          
        
      
        

          

            

            

                unless violation
          
        
      
        

          

            

            

                  transmit_error("Violation not found")
          
        
      
        

          

            

            

                  return
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                suggestion_engine = Branding::Compliance::SuggestionEngine.new(brand, [violation])
          
        
      
        

          

            

            

                fix = suggestion_engine.generate_fix(violation, content)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                transmit(
          
        
      
        

          

            

            

                  event: "fix_preview",
          
        
      
        

          

            

            

                  violation_id: violation_id,
          
        
      
        

          

            

            

                  fix: fix
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              rescue StandardError => e
          
        
      
        

          

            

            

                transmit_error("Fix generation failed: #{e.message}")
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              # Client can get suggestions for specific violation
          
        
      
        

          

            

            

              def get_suggestions(data)
          
        
      
        

          

            

            

                brand = find_brand
          
        
      
        

          

            

            

                return unless brand && authorized_to_check?(brand)
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                violation_ids = Array(data["violation_ids"])
          
        
      
        

          

            

            

                violations = find_session_violations(violation_ids)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                suggestion_engine = Branding::Compliance::SuggestionEngine.new(brand, violations)
          
        
      
        

          

            

            

                suggestions = suggestion_engine.generate_suggestions
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                transmit(
          
        
      
        

          

            

            

                  event: "suggestions_generated",
          
        
      
        

          

            

            

                  violation_ids: violation_ids,
          
        
      
        

          

            

            

                  suggestions: suggestions
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              rescue StandardError => e
          
        
      
        

          

            

            

                transmit_error("Suggestion generation failed: #{e.message}")
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def find_brand
          
        
      
        

          

            

            

                Brand.find_by(id: params[:brand_id])
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def authorized_to_check?(brand)
          
        
      
        

          

            

            

                # Check if current user has permission to check compliance for this brand
          
        
      
        

          

            

            

                return true if brand.user_id == current_user&.id
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Check team permissions
          
        
      
        

          

            

            

                current_user&.has_brand_permission?(brand, :check_compliance)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def build_check_options(data)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  session_id: params[:session_id],
          
        
      
        

          

            

            

                  user_id: current_user&.id,
          
        
      
        

          

            

            

                  broadcast_events: true,
          
        
      
        

          

            

            

                  compliance_level: data["compliance_level"]&.to_sym || :standard,
          
        
      
        

          

            

            

                  channel: data["channel"],
          
        
      
        

          

            

            

                  audience: data["audience"],
          
        
      
        

          

            

            

                  generate_suggestions: data["generate_suggestions"] != false,
          
        
      
        

          

            

            

                  visual_data: data["visual_data"]
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def perform_sync_check(brand, content, content_type, options)
          
        
      
        

          

            

            

                transmit(event: "check_started", mode: "sync")
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                service = Branding::ComplianceServiceV2.new(brand, content, content_type, options)
          
        
      
        

          

            

            

                results = service.check_compliance
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Store results in session cache
          
        
      
        

          

            

            

                cache_session_results(results)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                transmit(
          
        
      
        

          

            

            

                  event: "check_complete",
          
        
      
        

          

            

            

                  results: sanitize_results(results)
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              rescue StandardError => e
          
        
      
        

          

            

            

                transmit_error("Compliance check failed: #{e.message}")
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def perform_async_check(brand, content, content_type, options)
          
        
      
        

          

            

            

                transmit(event: "check_started", mode: "async")
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                job = BrandComplianceJob.perform_later(
          
        
      
        

          

            

            

                  brand.id,
          
        
      
        

          

            

            

                  content,
          
        
      
        

          

            

            

                  content_type,
          
        
      
        

          

            

            

                  options.merge(
          
        
      
        

          

            

            

                    broadcast_events: true,
          
        
      
        

          

            

            

                    session_id: params[:session_id]
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                transmit(
          
        
      
        

          

            

            

                  event: "job_queued",
          
        
      
        

          

            

            

                  job_id: job.job_id
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              rescue StandardError => e
          
        
      
        

          

            

            

                transmit_error("Failed to queue compliance check: #{e.message}")
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def cache_session_results(results)
          
        
      
        

          

            

            

                return unless params[:session_id]
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                Rails.cache.write(
          
        
      
        

          

            

            

                  "compliance_session:#{params[:session_id]}:results",
          
        
      
        

          

            

            

                  results,
          
        
      
        

          

            

            

                  expires_in: 1.hour
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def find_session_violation(violation_id)
          
        
      
        

          

            

            

                return unless params[:session_id]
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                results = Rails.cache.read("compliance_session:#{params[:session_id]}:results")
          
        
      
        

          

            

            

                results&.dig(:violations)&.find { |v| v[:id] == violation_id }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def find_session_violations(violation_ids)
          
        
      
        

          

            

            

                return [] unless params[:session_id]
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                results = Rails.cache.read("compliance_session:#{params[:session_id]}:results")
          
        
      
        

          

            

            

                violations = results&.dig(:violations) || []
          
        
      
        

          

            

            

                violations.select { |v| violation_ids.include?(v[:id]) }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def cancel_session_jobs(session_id)
          
        
      
        

          

            

            

                # Implementation would depend on job tracking system
          
        
      
        

          

            

            

                # This is a placeholder for canceling any ongoing jobs
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def transmit_error(message)
          
        
      
        

          

            

            

                transmit(
          
        
      
        

          

            

            

                  event: "error",
          
        
      
        

          

            

            

                  message: message,
          
        
      
        

          

            

            

                  timestamp: Time.current.iso8601
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

              def sanitize_results(results)
          
        
      
        

          

            

            

                # Remove any sensitive or unnecessary data before transmitting
          
        
      
        

          

            

            

                results.slice(
          
        
      
        

          

            

            

                  :compliant,
          
        
      
        

          

            

            

                  :score,
          
        
      
        

          

            

            

                  :summary,
          
        
      
        

          

            

            

                  :violations,
          
        
      
        

          

            

            

                  :suggestions,
          
        
      
        

          

            

            

                  :metadata
          
        
      
        

          

            

            

                ).deep_transform_values do |value|
          
        
      
        

          

            

            

                  case value
          
        
      
        

          

            

            

                  when ActiveRecord::Base
          
        
      
        

          

            

            

                    value.id
          
        
      
        

          

            

            

                  when Time, DateTime
          
        
      
        

          

            

            

                    value.iso8601
          
        
      
        

          

            

            

                  else
          
        
      
        

          

            

            

                    value
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class ActivitiesController < ApplicationController
          
        
      
        

          

            

            

              def index
          
        
      
        

          

            

            

                @activities = current_user.activities
          
        
      
        

          

            

            

                  .includes(:user)
          
        
      
        

          

            

            

                  .recent
          
        
      
        

          

            

            

                  .page(params[:page])
          
        
      
        

          

            

            

                  .per(25)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Filter by date range
          
        
      
        

          

            

            

                if params[:start_date].present?
          
        
      
        

          

            

            

                  @activities = @activities.where("occurred_at >= ?", params[:start_date])
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if params[:end_date].present?
          
        
      
        

          

            

            

                  @activities = @activities.where("occurred_at <= ?", params[:end_date])
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Filter by status
          
        
      
        

          

            

            

                case params[:status]
          
        
      
        

          

            

            

                when "suspicious"
          
        
      
        

          

            

            

                  @activities = @activities.suspicious
          
        
      
        

          

            

            

                when "failed"
          
        
      
        

          

            

            

                  @activities = @activities.failed_requests
          
        
      
        

          

            

            

                when "successful"
          
        
      
        

          

            

            

                  @activities = @activities.successful_requests
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Activity statistics
          
        
      
        

          

            

            

                @stats = {
          
        
      
        

          

            

            

                  total: current_user.activities.count,
          
        
      
        

          

            

            

                  today: current_user.activities.today.count,
          
        
      
        

          

            

            

                  this_week: current_user.activities.this_week.count,
          
        
      
        

          

            

            

                  suspicious: current_user.activities.suspicious.count,
          
        
      
        

          

            

            

                  failed_requests: current_user.activities.failed_requests.count
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class ActivityReportsController < ApplicationController
          
        
      
        

          

            

            

              before_action :require_authentication
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def show
          
        
      
        

          

            

            

                @start_date = params[:start_date] ? Date.parse(params[:start_date]) : 30.days.ago
          
        
      
        

          

            

            

                @end_date = params[:end_date] ? Date.parse(params[:end_date]) : Date.current
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                @report = ActivityReportService.new(
          
        
      
        

          

            

            

                  current_user,
          
        
      
        

          

            

            

                  start_date: @start_date,
          
        
      
        

          

            

            

                  end_date: @end_date
          
        
      
        

          

            

            

                ).generate_report
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                respond_to do |format|
          
        
      
        

          

            

            

                  format.html
          
        
      
        

          

            

            

                  format.json { render json: @report }
          
        
      
        

          

            

            

                  format.pdf { render_pdf } if defined?(Prawn)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def export
          
        
      
        

          

            

            

                @start_date = params[:start_date] ? Date.parse(params[:start_date]) : 30.days.ago
          
        
      
        

          

            

            

                @end_date = params[:end_date] ? Date.parse(params[:end_date]) : Date.current
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                activities = current_user.activities
          
        
      
        

          

            

            

                  .where(occurred_at: @start_date.beginning_of_day..@end_date.end_of_day)
          
        
      
        

          

            

            

                  .order(:occurred_at)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                respond_to do |format|
          
        
      
        

          

            

            

                  format.csv { send_data generate_csv(activities), filename: "activity_report_#{Date.current}.csv" }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def generate_csv(activities)
          
        
      
        

          

            

            

                require 'csv'
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                CSV.generate(headers: true) do |csv|
          
        
      
        

          

            

            

                  csv << [
          
        
      
        

          

            

            

                    'Date/Time',
          
        
      
        

          

            

            

                    'Action',
          
        
      
        

          

            

            

                    'Path',
          
        
      
        

          

            

            

                    'Method',
          
        
      
        

          

            

            

                    'Status',
          
        
      
        

          

            

            

                    'Response Time (ms)',
          
        
      
        

          

            

            

                    'IP Address',
          
        
      
        

          

            

            

                    'Device',
          
        
      
        

          

            

            

                    'Browser',
          
        
      
        

          

            

            

                    'OS',
          
        
      
        

          

            

            

                    'Suspicious',
          
        
      
        

          

            

            

                    'Reasons'
          
        
      
        

          

            

            

                  ]
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  activities.find_each do |activity|
          
        
      
        

          

            

            

                    csv << [
          
        
      
        

          

            

            

                      activity.occurred_at.strftime('%Y-%m-%d %H:%M:%S'),
          
        
      
        

          

            

            

                      activity.full_action,
          
        
      
        

          

            

            

                      activity.request_path,
          
        
      
        

          

            

            

                      activity.request_method,
          
        
      
        

          

            

            

                      activity.response_status,
          
        
      
        

          

            

            

                      activity.duration_in_ms,
          
        
      
        

          

            

            

                      activity.ip_address,
          
        
      
        

          

            

            

                      activity.device_type,
          
        
      
        

          

            

            

                      activity.browser_name,
          
        
      
        

          

            

            

                      activity.os_name,
          
        
      
        

          

            

            

                      activity.suspicious? ? 'Yes' : 'No',
          
        
      
        

          

            

            

                      activity.metadata['suspicious_reasons']&.join(', ')
          
        
      
        

          

            

            

                    ]
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def render_pdf
          
        
      
        

          

            

            

                # This would require the Prawn gem
          
        
      
        

          

            

            

                # Implementation depends on specific PDF requirements
          
        
      
        

          

            

            

                render plain: "PDF export not implemented", status: :not_implemented
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class Api::V1::AnalyticsController < Api::V1::BaseController
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/analytics/overview
          
        
      
        

          

            

            

              def overview
          
        
      
        

          

            

            

                days = [params[:days].to_i, 7].max
          
        
      
        

          

            

            

                days = [days, 365].min # Cap at 1 year
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                overview_data = {
          
        
      
        

          

            

            

                  summary: calculate_user_overview(days),
          
        
      
        

          

            

            

                  journeys: calculate_journey_overview(days),
          
        
      
        

          

            

            

                  campaigns: calculate_campaign_overview(days),
          
        
      
        

          

            

            

                  performance: calculate_performance_overview(days)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: overview_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/analytics/journeys/:id
          
        
      
        

          

            

            

              def journey_analytics
          
        
      
        

          

            

            

                journey = current_user.journeys.find(params[:id])
          
        
      
        

          

            

            

                days = [params[:days].to_i, 30].max
          
        
      
        

          

            

            

                days = [days, 365].min
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                analytics_data = {
          
        
      
        

          

            

            

                  summary: journey.analytics_summary(days),
          
        
      
        

          

            

            

                  performance_score: journey.latest_performance_score,
          
        
      
        

          

            

            

                  funnel_performance: journey.funnel_performance('default', days),
          
        
      
        

          

            

            

                  trends: journey.performance_trends(7),
          
        
      
        

          

            

            

                  ab_test_status: journey.ab_test_status,
          
        
      
        

          

            

            

                  step_analytics: calculate_step_analytics(journey, days),
          
        
      
        

          

            

            

                  conversion_metrics: calculate_journey_conversions(journey, days),
          
        
      
        

          

            

            

                  engagement_metrics: calculate_journey_engagement(journey, days)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: analytics_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/analytics/campaigns/:id
          
        
      
        

          

            

            

              def campaign_analytics
          
        
      
        

          

            

            

                campaign = current_user.campaigns.find(params[:id])
          
        
      
        

          

            

            

                days = [params[:days].to_i, 30].max
          
        
      
        

          

            

            

                days = [days, 365].min
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                analytics_service = CampaignAnalyticsService.new(campaign)
          
        
      
        

          

            

            

                analytics_data = analytics_service.generate_report(days)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: analytics_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/analytics/funnels/:journey_id
          
        
      
        

          

            

            

              def funnel_analytics
          
        
      
        

          

            

            

                journey = current_user.journeys.find(params[:journey_id])
          
        
      
        

          

            

            

                funnel_name = params[:funnel_name] || 'default'
          
        
      
        

          

            

            

                days = [params[:days].to_i, 7].max
          
        
      
        

          

            

            

                days = [days, 90].min
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                start_date = days.days.ago
          
        
      
        

          

            

            

                end_date = Time.current
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                funnel_data = {
          
        
      
        

          

            

            

                  overview: ConversionFunnel.funnel_overview(journey.id, funnel_name, start_date, end_date),
          
        
      
        

          

            

            

                  steps: ConversionFunnel.funnel_step_breakdown(journey.id, funnel_name, start_date, end_date),
          
        
      
        

          

            

            

                  trends: ConversionFunnel.funnel_trends(journey.id, funnel_name, start_date, end_date),
          
        
      
        

          

            

            

                  drop_off_analysis: calculate_drop_off_analysis(journey, funnel_name, start_date, end_date)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: funnel_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/analytics/ab_tests/:id
          
        
      
        

          

            

            

              def ab_test_analytics
          
        
      
        

          

            

            

                ab_test = current_user.ab_tests.find(params[:id])
          
        
      
        

          

            

            

                days = [params[:days].to_i, ab_test.duration_days].max
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                ab_analytics_service = AbTestAnalyticsService.new(ab_test)
          
        
      
        

          

            

            

                analytics_data = ab_analytics_service.generate_report(days)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: analytics_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/analytics/comparative
          
        
      
        

          

            

            

              def comparative_analytics
          
        
      
        

          

            

            

                journey_ids = params[:journey_ids].to_s.split(',').map(&:to_i)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if journey_ids.empty? || journey_ids.count > 5
          
        
      
        

          

            

            

                  return render_error(message: 'Please provide 1-5 journey IDs for comparison')
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                journeys = current_user.journeys.where(id: journey_ids)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                unless journeys.count == journey_ids.count
          
        
      
        

          

            

            

                  return render_error(message: 'One or more journeys not found')
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                days = [params[:days].to_i, 30].max
          
        
      
        

          

            

            

                days = [days, 90].min
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                comparison_service = JourneyComparisonService.new(journeys)
          
        
      
        

          

            

            

                comparison_data = comparison_service.generate_comparison(days)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: comparison_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/analytics/trends
          
        
      
        

          

            

            

              def trends
          
        
      
        

          

            

            

                days = [params[:days].to_i, 30].max
          
        
      
        

          

            

            

                days = [days, 365].min
          
        
      
        

          

            

            

                metric = params[:metric] || 'conversion_rate'
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                unless %w[conversion_rate engagement_score completion_rate execution_count].include?(metric)
          
        
      
        

          

            

            

                  return render_error(message: 'Invalid metric specified')
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                trends_data = calculate_user_trends(metric, days)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: trends_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/analytics/personas/:id/performance
          
        
      
        

          

            

            

              def persona_performance
          
        
      
        

          

            

            

                persona = current_user.personas.find(params[:id])
          
        
      
        

          

            

            

                days = [params[:days].to_i, 30].max
          
        
      
        

          

            

            

                days = [days, 365].min
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Get campaigns and journeys associated with this persona
          
        
      
        

          

            

            

                campaigns = persona.campaigns.includes(:journeys)
          
        
      
        

          

            

            

                journeys = campaigns.flat_map(&:journeys)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                performance_data = {
          
        
      
        

          

            

            

                  summary: calculate_persona_summary(persona, journeys, days),
          
        
      
        

          

            

            

                  campaign_performance: calculate_persona_campaign_performance(campaigns, days),
          
        
      
        

          

            

            

                  journey_performance: calculate_persona_journey_performance(journeys, days),
          
        
      
        

          

            

            

                  engagement_patterns: calculate_persona_engagement_patterns(persona, days),
          
        
      
        

          

            

            

                  conversion_insights: calculate_persona_conversion_insights(persona, days)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: performance_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # POST /api/v1/analytics/custom_report
          
        
      
        

          

            

            

              def custom_report
          
        
      
        

          

            

            

                report_params = params.permit(
          
        
      
        

          

            

            

                  :name, :description, :date_range_days,
          
        
      
        

          

            

            

                  metrics: [], filters: {}, grouping: []
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                begin
          
        
      
        

          

            

            

                  # Generate custom analytics report based on parameters
          
        
      
        

          

            

            

                  report_data = generate_custom_report(report_params)
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: report_data,
          
        
      
        

          

            

            

                    message: 'Custom report generated successfully'
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                rescue => e
          
        
      
        

          

            

            

                  render_error(message: "Failed to generate report: #{e.message}")
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/analytics/real_time
          
        
      
        

          

            

            

              def real_time
          
        
      
        

          

            

            

                # Get real-time metrics for the last 24 hours
          
        
      
        

          

            

            

                real_time_data = {
          
        
      
        

          

            

            

                  active_journeys: calculate_active_journeys,
          
        
      
        

          

            

            

                  recent_executions: calculate_recent_executions,
          
        
      
        

          

            

            

                  live_conversions: calculate_live_conversions,
          
        
      
        

          

            

            

                  engagement_activity: calculate_engagement_activity,
          
        
      
        

          

            

            

                  system_health: calculate_system_health
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: real_time_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_user_overview(days)
          
        
      
        

          

            

            

                journeys = current_user.journeys
          
        
      
        

          

            

            

                start_date = days.days.ago
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  total_journeys: journeys.count,
          
        
      
        

          

            

            

                  active_journeys: journeys.where(status: %w[draft published]).count,
          
        
      
        

          

            

            

                  total_executions: current_user.journey_executions.where(created_at: start_date..).count,
          
        
      
        

          

            

            

                  total_campaigns: current_user.campaigns.count,
          
        
      
        

          

            

            

                  total_personas: current_user.personas.count,
          
        
      
        

          

            

            

                  period_days: days
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_journey_overview(days)
          
        
      
        

          

            

            

                journeys = current_user.journeys.includes(:journey_analytics)
          
        
      
        

          

            

            

                start_date = days.days.ago
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                analytics = JourneyAnalytics.joins(:journey)
          
        
      
        

          

            

            

                  .where(journeys: { user: current_user })
          
        
      
        

          

            

            

                  .where(period_start: start_date..)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  average_conversion_rate: analytics.average(:conversion_rate)&.round(2) || 0,
          
        
      
        

          

            

            

                  average_engagement_score: analytics.average(:engagement_score)&.round(2) || 0,
          
        
      
        

          

            

            

                  total_executions: analytics.sum(:total_executions),
          
        
      
        

          

            

            

                  completed_executions: analytics.sum(:completed_executions),
          
        
      
        

          

            

            

                  top_performing: find_top_performing_journeys(5)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_campaign_overview(days)
          
        
      
        

          

            

            

                campaigns = current_user.campaigns.includes(:journeys)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  active_campaigns: campaigns.where(status: 'active').count,
          
        
      
        

          

            

            

                  total_journey_count: campaigns.joins(:journeys).count,
          
        
      
        

          

            

            

                  campaign_performance: campaigns.limit(5).map do |campaign|
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: campaign.id,
          
        
      
        

          

            

            

                      name: campaign.name,
          
        
      
        

          

            

            

                      journey_count: campaign.journeys.count,
          
        
      
        

          

            

            

                      status: campaign.status
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_performance_overview(days)
          
        
      
        

          

            

            

                start_date = days.days.ago
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Get performance metrics across all user's journeys
          
        
      
        

          

            

            

                user_journey_ids = current_user.journeys.pluck(:id)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                metrics = JourneyMetric.where(journey_id: user_journey_ids)
          
        
      
        

          

            

            

                  .for_date_range(start_date, Time.current)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  average_performance_score: calculate_average_performance_score(metrics),
          
        
      
        

          

            

            

                  trend_direction: calculate_trend_direction(metrics),
          
        
      
        

          

            

            

                  key_insights: generate_key_insights(metrics)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_step_analytics(journey, days)
          
        
      
        

          

            

            

                journey.journey_steps.includes(:step_executions).map do |step|
          
        
      
        

          

            

            

                  executions = step.step_executions.where(created_at: days.days.ago..)
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    step_id: step.id,
          
        
      
        

          

            

            

                    step_name: step.name,
          
        
      
        

          

            

            

                    step_type: step.content_type,
          
        
      
        

          

            

            

                    execution_count: executions.count,
          
        
      
        

          

            

            

                    completion_rate: calculate_step_completion_rate(executions),
          
        
      
        

          

            

            

                    average_duration: calculate_average_duration(executions)
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_journey_conversions(journey, days)
          
        
      
        

          

            

            

                # Placeholder for detailed conversion calculations
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  total_conversions: 0,
          
        
      
        

          

            

            

                  conversion_rate: 0.0,
          
        
      
        

          

            

            

                  conversion_value: 0.0,
          
        
      
        

          

            

            

                  conversion_by_source: {},
          
        
      
        

          

            

            

                  conversion_trends: []
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_journey_engagement(journey, days)
          
        
      
        

          

            

            

                # Placeholder for engagement calculations
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  engagement_score: 0.0,
          
        
      
        

          

            

            

                  interaction_count: 0,
          
        
      
        

          

            

            

                  average_session_duration: 0.0,
          
        
      
        

          

            

            

                  bounce_rate: 0.0,
          
        
      
        

          

            

            

                  engagement_by_step: []
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_drop_off_analysis(journey, funnel_name, start_date, end_date)
          
        
      
        

          

            

            

                # Analyze where users drop off in the funnel
          
        
      
        

          

            

            

                steps = journey.journey_steps.order(:position)
          
        
      
        

          

            

            

                drop_off_data = []
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                steps.each_with_index do |step, index|
          
        
      
        

          

            

            

                  next_step = steps[index + 1]
          
        
      
        

          

            

            

                  next unless next_step
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  # Calculate drop-off rate between this step and the next
          
        
      
        

          

            

            

                  current_executions = step.step_executions.where(created_at: start_date..end_date).count
          
        
      
        

          

            

            

                  next_executions = next_step.step_executions.where(created_at: start_date..end_date).count
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  drop_off_rate = current_executions > 0 ? ((current_executions - next_executions).to_f / current_executions * 100).round(2) : 0
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  drop_off_data << {
          
        
      
        

          

            

            

                    from_step: step.name,
          
        
      
        

          

            

            

                    to_step: next_step.name,
          
        
      
        

          

            

            

                    drop_off_rate: drop_off_rate,
          
        
      
        

          

            

            

                    users_lost: current_executions - next_executions
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                drop_off_data
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def find_top_performing_journeys(limit)
          
        
      
        

          

            

            

                current_user.journeys
          
        
      
        

          

            

            

                  .joins(:journey_analytics)
          
        
      
        

          

            

            

                  .group('journeys.id, journeys.name')
          
        
      
        

          

            

            

                  .order('AVG(journey_analytics.conversion_rate) DESC')
          
        
      
        

          

            

            

                  .limit(limit)
          
        
      
        

          

            

            

                  .pluck('journeys.id, journeys.name, AVG(journey_analytics.conversion_rate)')
          
        
      
        

          

            

            

                  .map { |id, name, rate| { id: id, name: name, conversion_rate: rate.round(2) } }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_average_performance_score(metrics)
          
        
      
        

          

            

            

                return 0.0 if metrics.empty?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Calculate weighted performance score across all metrics
          
        
      
        

          

            

            

                total_score = metrics.sum do |metric|
          
        
      
        

          

            

            

                  conversion_weight = 0.4
          
        
      
        

          

            

            

                  engagement_weight = 0.3
          
        
      
        

          

            

            

                  completion_weight = 0.3
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  (metric.conversion_rate * conversion_weight +
          
        
      
        

          

            

            

                   metric.engagement_score * engagement_weight +
          
        
      
        

          

            

            

                   metric.completion_rate * completion_weight)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                (total_score / metrics.count).round(1)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_trend_direction(metrics)
          
        
      
        

          

            

            

                return 'stable' if metrics.count < 2
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                recent_scores = metrics.order(:period_start).last(7).map(&:conversion_rate)
          
        
      
        

          

            

            

                return 'stable' if recent_scores.count < 2
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                trend = (recent_scores.last - recent_scores.first) / recent_scores.first
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if trend > 0.05
          
        
      
        

          

            

            

                  'improving'
          
        
      
        

          

            

            

                elsif trend < -0.05
          
        
      
        

          

            

            

                  'declining'
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  'stable'
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def generate_key_insights(metrics)
          
        
      
        

          

            

            

                insights = []
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Add performance insights based on metrics analysis
          
        
      
        

          

            

            

                if metrics.any?
          
        
      
        

          

            

            

                  avg_conversion = metrics.average(:conversion_rate)
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  if avg_conversion > 10
          
        
      
        

          

            

            

                    insights << "Strong conversion performance across journeys"
          
        
      
        

          

            

            

                  elsif avg_conversion < 2
          
        
      
        

          

            

            

                    insights << "Conversion rates could be improved"
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  high_engagement = metrics.where('engagement_score > ?', 75).count
          
        
      
        

          

            

            

                  if high_engagement > metrics.count * 0.7
          
        
      
        

          

            

            

                    insights << "High engagement levels maintained"
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                insights
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_user_trends(metric, days)
          
        
      
        

          

            

            

                # Calculate trends for specified metric over time
          
        
      
        

          

            

            

                user_journey_ids = current_user.journeys.pluck(:id)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                analytics = JourneyAnalytics.where(journey_id: user_journey_ids)
          
        
      
        

          

            

            

                  .where(period_start: days.days.ago..)
          
        
      
        

          

            

            

                  .order(:period_start)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                trends = analytics.group("DATE(period_start)").average(metric)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  metric: metric,
          
        
      
        

          

            

            

                  period_days: days,
          
        
      
        

          

            

            

                  data_points: trends.map { |date, value| { date: date, value: value&.round(2) || 0 } }
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_persona_summary(persona, journeys, days)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  persona_name: persona.name,
          
        
      
        

          

            

            

                  total_journeys: journeys.count,
          
        
      
        

          

            

            

                  total_campaigns: persona.campaigns.count,
          
        
      
        

          

            

            

                  performance_score: calculate_persona_performance_score(journeys, days)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_persona_campaign_performance(campaigns, days)
          
        
      
        

          

            

            

                campaigns.map do |campaign|
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: campaign.id,
          
        
      
        

          

            

            

                    name: campaign.name,
          
        
      
        

          

            

            

                    status: campaign.status,
          
        
      
        

          

            

            

                    journey_count: campaign.journeys.count
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_persona_journey_performance(journeys, days)
          
        
      
        

          

            

            

                journeys.map do |journey|
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: journey.id,
          
        
      
        

          

            

            

                    name: journey.name,
          
        
      
        

          

            

            

                    performance_score: journey.latest_performance_score,
          
        
      
        

          

            

            

                    conversion_rate: journey.current_analytics&.conversion_rate || 0
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_persona_engagement_patterns(persona, days)
          
        
      
        

          

            

            

                # Placeholder for persona engagement analysis
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  preferred_channels: [],
          
        
      
        

          

            

            

                  engagement_times: [],
          
        
      
        

          

            

            

                  content_preferences: []
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_persona_conversion_insights(persona, days)
          
        
      
        

          

            

            

                # Placeholder for persona conversion analysis
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  conversion_triggers: [],
          
        
      
        

          

            

            

                  optimal_journey_length: 0,
          
        
      
        

          

            

            

                  successful_touchpoints: []
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_persona_performance_score(journeys, days)
          
        
      
        

          

            

            

                return 0.0 if journeys.empty?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                scores = journeys.map(&:latest_performance_score).compact
          
        
      
        

          

            

            

                return 0.0 if scores.empty?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                (scores.sum.to_f / scores.count).round(1)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def generate_custom_report(report_params)
          
        
      
        

          

            

            

                # Placeholder for custom report generation
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  report_name: report_params[:name],
          
        
      
        

          

            

            

                  generated_at: Time.current,
          
        
      
        

          

            

            

                  data: {
          
        
      
        

          

            

            

                    summary: "Custom report functionality would be implemented here",
          
        
      
        

          

            

            

                    metrics: report_params[:metrics] || [],
          
        
      
        

          

            

            

                    filters_applied: report_params[:filters] || {}
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_active_journeys
          
        
      
        

          

            

            

                current_user.journeys.where(status: %w[draft published]).count
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_recent_executions
          
        
      
        

          

            

            

                current_user.journey_executions.where(created_at: 24.hours.ago..).count
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_live_conversions
          
        
      
        

          

            

            

                # Placeholder for real-time conversion tracking
          
        
      
        

          

            

            

                0
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_engagement_activity
          
        
      
        

          

            

            

                # Placeholder for real-time engagement tracking
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  active_sessions: 0,
          
        
      
        

          

            

            

                  recent_interactions: 0
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_system_health
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  status: 'healthy',
          
        
      
        

          

            

            

                  response_time: 'normal',
          
        
      
        

          

            

            

                  uptime: '99.9%'
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_step_completion_rate(executions)
          
        
      
        

          

            

            

                return 0.0 if executions.empty?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                completed_count = executions.completed.count
          
        
      
        

          

            

            

                total_count = executions.count
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                return 0.0 if total_count == 0
          
        
      
        

          

            

            

                (completed_count.to_f / total_count * 100).round(2)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_average_duration(executions)
          
        
      
        

          

            

            

                completed_executions = executions.completed.where.not(completed_at: nil, started_at: nil)
          
        
      
        

          

            

            

                return 0.0 if completed_executions.empty?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                durations = completed_executions.map do |execution|
          
        
      
        

          

            

            

                  (execution.completed_at - execution.started_at) / 1.hour # Convert to hours
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                (durations.sum / durations.count).round(2)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class Api::V1::BaseController < ApplicationController
          
        
      
        

          

            

            

              # Skip CSRF protection for API endpoints
          
        
      
        

          

            

            

              skip_before_action :verify_authenticity_token
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # Use JSON format by default
          
        
      
        

          

            

            

              before_action :set_default_format
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # Include API-specific concerns
          
        
      
        

          

            

            

              include ApiAuthentication
          
        
      
        

          

            

            

              include ApiErrorHandling
          
        
      
        

          

            

            

              include ApiPagination
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def set_default_format
          
        
      
        

          

            

            

                request.format = :json unless params[:format]
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # API-specific success response format
          
        
      
        

          

            

            

              def render_success(data: nil, message: nil, status: :ok, meta: {})
          
        
      
        

          

            

            

                response_body = { success: true }
          
        
      
        

          

            

            

                response_body[:data] = data if data
          
        
      
        

          

            

            

                response_body[:message] = message if message
          
        
      
        

          

            

            

                response_body[:meta] = meta if meta.any?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render json: response_body, status: status
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # API-specific error response format
          
        
      
        

          

            

            

              def render_error(message: nil, errors: {}, status: :unprocessable_entity, code: nil)
          
        
      
        

          

            

            

                response_body = { 
          
        
      
        

          

            

            

                  success: false,
          
        
      
        

          

            

            

                  message: message || 'An error occurred'
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                response_body[:code] = code if code
          
        
      
        

          

            

            

                response_body[:errors] = errors if errors.any?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render json: response_body, status: status
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # Ensure user can only access their own resources
          
        
      
        

          

            

            

              def ensure_user_resource_access(resource)
          
        
      
        

          

            

            

                unless resource&.user == current_user
          
        
      
        

          

            

            

                  render_error(message: 'Resource not found', status: :not_found)
          
        
      
        

          

            

            

                  return false
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                true
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            module Api
          
        
      
        

          

            

            

              module V1
          
        
      
        

          

            

            

                class BrandComplianceController < ApplicationController
          
        
      
        

          

            

            

                  before_action :authenticate_user!
          
        
      
        

          

            

            

                  before_action :set_brand
          
        
      
        

          

            

            

                  before_action :authorize_brand_access
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # POST /api/v1/brands/:brand_id/compliance/check
          
        
      
        

          

            

            

                  def check
          
        
      
        

          

            

            

                    content = compliance_params[:content]
          
        
      
        

          

            

            

                    content_type = compliance_params[:content_type] || "general"
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    if content.blank?
          
        
      
        

          

            

            

                      render json: { error: "Content is required" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                      return
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    options = build_compliance_options
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    # Use async processing for large content
          
        
      
        

          

            

            

                    if content.length > 10_000 && params[:sync] != "true"
          
        
      
        

          

            

            

                      job = BrandComplianceJob.perform_later(
          
        
      
        

          

            

            

                        @brand.id,
          
        
      
        

          

            

            

                        content,
          
        
      
        

          

            

            

                        content_type,
          
        
      
        

          

            

            

                        options.merge(
          
        
      
        

          

            

            

                          user_id: current_user.id,
          
        
      
        

          

            

            

                          notify: params[:notify] == "true",
          
        
      
        

          

            

            

                          store_results: true
          
        
      
        

          

            

            

                        )
          
        
      
        

          

            

            

                      )
          
        
      
        

          

            

            

                      
          
        
      
        

          

            

            

                      render json: {
          
        
      
        

          

            

            

                        status: "processing",
          
        
      
        

          

            

            

                        job_id: job.job_id,
          
        
      
        

          

            

            

                        message: "Compliance check queued for processing"
          
        
      
        

          

            

            

                      }, status: :accepted
          
        
      
        

          

            

            

                    else
          
        
      
        

          

            

            

                      service = Branding::ComplianceServiceV2.new(@brand, content, content_type, options)
          
        
      
        

          

            

            

                      results = service.check_compliance
          
        
      
        

          

            

            

                      
          
        
      
        

          

            

            

                      # Store results if requested
          
        
      
        

          

            

            

                      store_results(results) if params[:store_results] == "true"
          
        
      
        

          

            

            

                      
          
        
      
        

          

            

            

                      render json: format_compliance_results(results)
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

                  rescue StandardError => e
          
        
      
        

          

            

            

                    render json: { error: e.message }, status: :internal_server_error
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # POST /api/v1/brands/:brand_id/compliance/validate_aspect
          
        
      
        

          

            

            

                  def validate_aspect
          
        
      
        

          

            

            

                    aspect = params[:aspect]&.to_sym
          
        
      
        

          

            

            

                    content = compliance_params[:content]
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    unless %i[tone sentiment readability brand_voice colors typography logo composition].include?(aspect)
          
        
      
        

          

            

            

                      render json: { error: "Invalid aspect: #{aspect}" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                      return
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    service = Branding::ComplianceServiceV2.new(@brand, content, "general", build_compliance_options)
          
        
      
        

          

            

            

                    results = service.check_specific_aspects([aspect])
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      aspect: aspect,
          
        
      
        

          

            

            

                      results: results[aspect],
          
        
      
        

          

            

            

                      timestamp: Time.current
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  rescue StandardError => e
          
        
      
        

          

            

            

                    render json: { error: e.message }, status: :internal_server_error
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # POST /api/v1/brands/:brand_id/compliance/preview_fix
          
        
      
        

          

            

            

                  def preview_fix
          
        
      
        

          

            

            

                    violation = params[:violation]
          
        
      
        

          

            

            

                    content = compliance_params[:content]
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    unless violation.present?
          
        
      
        

          

            

            

                      render json: { error: "Violation data is required" }, status: :unprocessable_entity
          
        
      
        

          

            

            

                      return
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                    suggestion_engine = Branding::Compliance::SuggestionEngine.new(@brand, [violation])
          
        
      
        

          

            

            

                    fix = suggestion_engine.generate_fix(violation, content)
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      violation_id: violation[:id],
          
        
      
        

          

            

            

                      fix: fix,
          
        
      
        

          

            

            

                      alternatives: suggestion_engine.suggest_alternatives(
          
        
      
        

          

            

            

                        content[0..100],
          
        
      
        

          

            

            

                        { content_type: params[:content_type], audience: params[:audience] }
          
        
      
        

          

            

            

                      )
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  rescue StandardError => e
          
        
      
        

          

            

            

                    render json: { error: e.message }, status: :internal_server_error
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # GET /api/v1/brands/:brand_id/compliance/history
          
        
      
        

          

            

            

                  def history
          
        
      
        

          

            

            

                    results = @brand.compliance_results
          
        
      
        

          

            

            

                                   .by_content_type(params[:content_type])
          
        
      
        

          

            

            

                                   .recent
          
        
      
        

          

            

            

                                   .page(params[:page])
          
        
      
        

          

            

            

                                   .per(params[:per_page] || 20)
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      results: results.map { |r| format_history_result(r) },
          
        
      
        

          

            

            

                      pagination: {
          
        
      
        

          

            

            

                        current_page: results.current_page,
          
        
      
        

          

            

            

                        total_pages: results.total_pages,
          
        
      
        

          

            

            

                        total_count: results.total_count
          
        
      
        

          

            

            

                      },
          
        
      
        

          

            

            

                      statistics: {
          
        
      
        

          

            

            

                        average_score: results.average_score,
          
        
      
        

          

            

            

                        compliance_rate: results.compliance_rate,
          
        
      
        

          

            

            

                        common_violations: @brand.compliance_results.common_violations(5)
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  # POST /api/v1/brands/:brand_id/compliance/validate_and_fix
          
        
      
        

          

            

            

                  def validate_and_fix
          
        
      
        

          

            

            

                    content = compliance_params[:content]
          
        
      
        

          

            

            

                    content_type = compliance_params[:content_type] || "general"
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    service = Branding::ComplianceServiceV2.new(@brand, content, content_type, build_compliance_options)
          
        
      
        

          

            

            

                    results = service.validate_and_fix
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    render json: {
          
        
      
        

          

            

            

                      original_compliant: results[:original_results][:compliant],
          
        
      
        

          

            

            

                      original_score: results[:original_results][:score],
          
        
      
        

          

            

            

                      fixes_applied: results[:fixes_applied],
          
        
      
        

          

            

            

                      final_compliant: results[:final_results][:compliant],
          
        
      
        

          

            

            

                      final_score: results[:final_results][:score],
          
        
      
        

          

            

            

                      fixed_content: results[:fixed_content]
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  rescue StandardError => e
          
        
      
        

          

            

            

                    render json: { error: e.message }, status: :internal_server_error
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  private
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  def set_brand
          
        
      
        

          

            

            

                    @brand = Brand.find(params[:brand_id])
          
        
      
        

          

            

            

                  rescue ActiveRecord::RecordNotFound
          
        
      
        

          

            

            

                    render json: { error: "Brand not found" }, status: :not_found
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  def authorize_brand_access
          
        
      
        

          

            

            

                    unless @brand.user_id == current_user.id || current_user.has_brand_permission?(@brand, :check_compliance)
          
        
      
        

          

            

            

                      render json: { error: "Unauthorized" }, status: :forbidden
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  def compliance_params
          
        
      
        

          

            

            

                    params.permit(:content, :content_type, :visual_data => {})
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  def build_compliance_options
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      compliance_level: (params[:compliance_level] || "standard").to_sym,
          
        
      
        

          

            

            

                      generate_suggestions: params[:suggestions] != "false",
          
        
      
        

          

            

            

                      channel: params[:channel],
          
        
      
        

          

            

            

                      audience: params[:audience],
          
        
      
        

          

            

            

                      cache_results: params[:cache] != "false",
          
        
      
        

          

            

            

                      visual_data: params[:visual_data]
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  def store_results(results)
          
        
      
        

          

            

            

                    ComplianceResult.create!(
          
        
      
        

          

            

            

                      brand: @brand,
          
        
      
        

          

            

            

                      content_type: params[:content_type] || "general",
          
        
      
        

          

            

            

                      content_hash: Digest::SHA256.hexdigest(compliance_params[:content]),
          
        
      
        

          

            

            

                      compliant: results[:compliant],
          
        
      
        

          

            

            

                      score: results[:score],
          
        
      
        

          

            

            

                      violations_count: results[:violations]&.count || 0,
          
        
      
        

          

            

            

                      violations_data: results[:violations] || [],
          
        
      
        

          

            

            

                      suggestions_data: results[:suggestions] || [],
          
        
      
        

          

            

            

                      analysis_data: results[:analysis] || {},
          
        
      
        

          

            

            

                      metadata: results[:metadata] || {}
          
        
      
        

          

            

            

                    )
          
        
      
        

          

            

            

                  rescue StandardError => e
          
        
      
        

          

            

            

                    Rails.logger.error "Failed to store compliance results: #{e.message}"
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  def format_compliance_results(results)
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      compliant: results[:compliant],
          
        
      
        

          

            

            

                      score: results[:score],
          
        
      
        

          

            

            

                      summary: results[:summary],
          
        
      
        

          

            

            

                      violations: format_violations(results[:violations]),
          
        
      
        

          

            

            

                      suggestions: format_suggestions(results[:suggestions]),
          
        
      
        

          

            

            

                      metadata: {
          
        
      
        

          

            

            

                        processing_time: results[:metadata][:processing_time],
          
        
      
        

          

            

            

                        validators_used: results[:metadata][:validators_used],
          
        
      
        

          

            

            

                        compliance_level: results[:metadata][:compliance_level],
          
        
      
        

          

            

            

                        timestamp: Time.current
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  def format_violations(violations)
          
        
      
        

          

            

            

                    return [] unless violations
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    violations.map do |violation|
          
        
      
        

          

            

            

                      {
          
        
      
        

          

            

            

                        id: violation[:id],
          
        
      
        

          

            

            

                        type: violation[:type],
          
        
      
        

          

            

            

                        severity: violation[:severity],
          
        
      
        

          

            

            

                        message: violation[:message],
          
        
      
        

          

            

            

                        validator: violation[:validator_type],
          
        
      
        

          

            

            

                        position: violation[:position],
          
        
      
        

          

            

            

                        details: violation[:details]
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  def format_suggestions(suggestions)
          
        
      
        

          

            

            

                    return [] unless suggestions
          
        
      
        

          

            

            

                    
          
        
      
        

          

            

            

                    suggestions.map do |suggestion|
          
        
      
        

          

            

            

                      {
          
        
      
        

          

            

            

                        type: suggestion[:type],
          
        
      
        

          

            

            

                        priority: suggestion[:priority],
          
        
      
        

          

            

            

                        title: suggestion[:title],
          
        
      
        

          

            

            

                        description: suggestion[:description],
          
        
      
        

          

            

            

                        actions: suggestion[:specific_actions],
          
        
      
        

          

            

            

                        effort: suggestion[:effort_level],
          
        
      
        

          

            

            

                        estimated_time: suggestion[:estimated_time]
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    end
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

            
          
        
      
        

          

            

            

                  def format_history_result(result)
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: result.id,
          
        
      
        

          

            

            

                      content_type: result.content_type,
          
        
      
        

          

            

            

                      compliant: result.compliant,
          
        
      
        

          

            

            

                      score: result.score,
          
        
      
        

          

            

            

                      violations_count: result.violations_count,
          
        
      
        

          

            

            

                      high_severity_count: result.high_severity_violations.count,
          
        
      
        

          

            

            

                      created_at: result.created_at,
          
        
      
        

          

            

            

                      processing_time: result.processing_time_seconds
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class Api::V1::CampaignsController < Api::V1::BaseController
          
        
      
        

          

            

            

              before_action :set_campaign, only: [:show, :update, :destroy, :activate, :pause, :analytics]
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/campaigns
          
        
      
        

          

            

            

              def index
          
        
      
        

          

            

            

                campaigns = current_user.campaigns.includes(:persona, :journeys)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Apply filters
          
        
      
        

          

            

            

                campaigns = campaigns.where(status: params[:status]) if params[:status].present?
          
        
      
        

          

            

            

                campaigns = campaigns.where(campaign_type: params[:campaign_type]) if params[:campaign_type].present?
          
        
      
        

          

            

            

                campaigns = campaigns.where(industry: params[:industry]) if params[:industry].present?
          
        
      
        

          

            

            

                campaigns = campaigns.where(persona_id: params[:persona_id]) if params[:persona_id].present?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Apply search
          
        
      
        

          

            

            

                if params[:search].present?
          
        
      
        

          

            

            

                  campaigns = campaigns.where(
          
        
      
        

          

            

            

                    'name ILIKE ? OR description ILIKE ?',
          
        
      
        

          

            

            

                    "%#{params[:search]}%", "%#{params[:search]}%"
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Apply sorting
          
        
      
        

          

            

            

                case params[:sort_by]
          
        
      
        

          

            

            

                when 'name'
          
        
      
        

          

            

            

                  campaigns = campaigns.order(:name)
          
        
      
        

          

            

            

                when 'status'
          
        
      
        

          

            

            

                  campaigns = campaigns.order(:status, :name)
          
        
      
        

          

            

            

                when 'created_at'
          
        
      
        

          

            

            

                  campaigns = campaigns.order(:created_at)
          
        
      
        

          

            

            

                when 'updated_at'
          
        
      
        

          

            

            

                  campaigns = campaigns.order(:updated_at)
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  campaigns = campaigns.order(updated_at: :desc)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                paginate_and_render(campaigns, serializer: method(:serialize_campaign_summary))
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/campaigns/:id
          
        
      
        

          

            

            

              def show
          
        
      
        

          

            

            

                render_success(data: serialize_campaign_detail(@campaign))
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # POST /api/v1/campaigns
          
        
      
        

          

            

            

              def create
          
        
      
        

          

            

            

                campaign = current_user.campaigns.build(campaign_params)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if campaign.save
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: serialize_campaign_detail(campaign),
          
        
      
        

          

            

            

                    message: 'Campaign created successfully',
          
        
      
        

          

            

            

                    status: :created
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render_error(
          
        
      
        

          

            

            

                    message: 'Failed to create campaign',
          
        
      
        

          

            

            

                    errors: campaign.errors.as_json
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # PUT /api/v1/campaigns/:id
          
        
      
        

          

            

            

              def update
          
        
      
        

          

            

            

                if @campaign.update(campaign_params)
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: serialize_campaign_detail(@campaign),
          
        
      
        

          

            

            

                    message: 'Campaign updated successfully'
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render_error(
          
        
      
        

          

            

            

                    message: 'Failed to update campaign',
          
        
      
        

          

            

            

                    errors: @campaign.errors.as_json
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # DELETE /api/v1/campaigns/:id
          
        
      
        

          

            

            

              def destroy
          
        
      
        

          

            

            

                @campaign.destroy!
          
        
      
        

          

            

            

                render_success(message: 'Campaign deleted successfully')
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # POST /api/v1/campaigns/:id/activate
          
        
      
        

          

            

            

              def activate
          
        
      
        

          

            

            

                if @campaign.activate!
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: serialize_campaign_detail(@campaign),
          
        
      
        

          

            

            

                    message: 'Campaign activated successfully'
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render_error(
          
        
      
        

          

            

            

                    message: 'Failed to activate campaign',
          
        
      
        

          

            

            

                    errors: @campaign.errors.as_json
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # POST /api/v1/campaigns/:id/pause
          
        
      
        

          

            

            

              def pause
          
        
      
        

          

            

            

                if @campaign.pause!
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: serialize_campaign_detail(@campaign),
          
        
      
        

          

            

            

                    message: 'Campaign paused successfully'
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render_error(
          
        
      
        

          

            

            

                    message: 'Failed to pause campaign',
          
        
      
        

          

            

            

                    errors: @campaign.errors.as_json
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/campaigns/:id/analytics
          
        
      
        

          

            

            

              def analytics
          
        
      
        

          

            

            

                days = [params[:days].to_i, 30].max
          
        
      
        

          

            

            

                days = [days, 365].min
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                analytics_service = CampaignAnalyticsService.new(@campaign)
          
        
      
        

          

            

            

                analytics_data = analytics_service.generate_report(days)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: analytics_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/campaigns/:id/journeys
          
        
      
        

          

            

            

              def journeys
          
        
      
        

          

            

            

                journeys = @campaign.journeys.includes(:journey_steps, :journey_analytics)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Apply filters
          
        
      
        

          

            

            

                journeys = journeys.where(status: params[:status]) if params[:status].present?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Apply sorting
          
        
      
        

          

            

            

                case params[:sort_by]
          
        
      
        

          

            

            

                when 'name'
          
        
      
        

          

            

            

                  journeys = journeys.order(:name)
          
        
      
        

          

            

            

                when 'performance'
          
        
      
        

          

            

            

                  # Sort by latest performance score
          
        
      
        

          

            

            

                  journeys = journeys.joins(:journey_analytics)
          
        
      
        

          

            

            

                    .group('journeys.id')
          
        
      
        

          

            

            

                    .order('AVG(journey_analytics.conversion_rate) DESC')
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  journeys = journeys.order(created_at: :desc)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                paginate_and_render(journeys, serializer: method(:serialize_journey_for_campaign))
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # POST /api/v1/campaigns/:id/journeys
          
        
      
        

          

            

            

              def add_journey
          
        
      
        

          

            

            

                journey_params = params.require(:journey).permit(:id, :name, :description)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if journey_params[:id].present?
          
        
      
        

          

            

            

                  # Associate existing journey
          
        
      
        

          

            

            

                  journey = current_user.journeys.find(journey_params[:id])
          
        
      
        

          

            

            

                  journey.update!(campaign: @campaign)
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  # Create new journey for campaign
          
        
      
        

          

            

            

                  journey = @campaign.journeys.build(
          
        
      
        

          

            

            

                    journey_params.merge(user: current_user)
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                  journey.save!
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(
          
        
      
        

          

            

            

                  data: serialize_journey_for_campaign(journey),
          
        
      
        

          

            

            

                  message: 'Journey added to campaign successfully',
          
        
      
        

          

            

            

                  status: :created
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # DELETE /api/v1/campaigns/:id/journeys/:journey_id
          
        
      
        

          

            

            

              def remove_journey
          
        
      
        

          

            

            

                journey = @campaign.journeys.find(params[:journey_id])
          
        
      
        

          

            

            

                journey.update!(campaign: nil)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(message: 'Journey removed from campaign successfully')
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/campaigns/industries
          
        
      
        

          

            

            

              def industries
          
        
      
        

          

            

            

                industries = Campaign.where(user: current_user).distinct.pluck(:industry).compact.sort
          
        
      
        

          

            

            

                render_success(data: industries)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/campaigns/types
          
        
      
        

          

            

            

              def types
          
        
      
        

          

            

            

                types = Campaign::CAMPAIGN_TYPES
          
        
      
        

          

            

            

                render_success(data: types)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def set_campaign
          
        
      
        

          

            

            

                @campaign = current_user.campaigns.find(params[:id])
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def campaign_params
          
        
      
        

          

            

            

                params.require(:campaign).permit(
          
        
      
        

          

            

            

                  :name, :description, :campaign_type, :industry, :status,
          
        
      
        

          

            

            

                  :start_date, :end_date, :budget, :persona_id,
          
        
      
        

          

            

            

                  goals: [], target_metrics: {}, settings: {}
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def serialize_campaign_summary(campaign)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  id: campaign.id,
          
        
      
        

          

            

            

                  name: campaign.name,
          
        
      
        

          

            

            

                  description: campaign.description,
          
        
      
        

          

            

            

                  campaign_type: campaign.campaign_type,
          
        
      
        

          

            

            

                  industry: campaign.industry,
          
        
      
        

          

            

            

                  status: campaign.status,
          
        
      
        

          

            

            

                  persona_id: campaign.persona_id,
          
        
      
        

          

            

            

                  persona_name: campaign.persona&.name,
          
        
      
        

          

            

            

                  journey_count: campaign.journeys.count,
          
        
      
        

          

            

            

                  start_date: campaign.start_date,
          
        
      
        

          

            

            

                  end_date: campaign.end_date,
          
        
      
        

          

            

            

                  budget: campaign.budget,
          
        
      
        

          

            

            

                  created_at: campaign.created_at,
          
        
      
        

          

            

            

                  updated_at: campaign.updated_at
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def serialize_campaign_detail(campaign)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  id: campaign.id,
          
        
      
        

          

            

            

                  name: campaign.name,
          
        
      
        

          

            

            

                  description: campaign.description,
          
        
      
        

          

            

            

                  campaign_type: campaign.campaign_type,
          
        
      
        

          

            

            

                  industry: campaign.industry,
          
        
      
        

          

            

            

                  status: campaign.status,
          
        
      
        

          

            

            

                  start_date: campaign.start_date,
          
        
      
        

          

            

            

                  end_date: campaign.end_date,
          
        
      
        

          

            

            

                  budget: campaign.budget,
          
        
      
        

          

            

            

                  goals: campaign.goals,
          
        
      
        

          

            

            

                  target_metrics: campaign.target_metrics,
          
        
      
        

          

            

            

                  settings: campaign.settings,
          
        
      
        

          

            

            

                  persona: campaign.persona ? serialize_persona_for_campaign(campaign.persona) : nil,
          
        
      
        

          

            

            

                  journey_count: campaign.journeys.count,
          
        
      
        

          

            

            

                  created_at: campaign.created_at,
          
        
      
        

          

            

            

                  updated_at: campaign.updated_at
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def serialize_persona_for_campaign(persona)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  id: persona.id,
          
        
      
        

          

            

            

                  name: persona.name,
          
        
      
        

          

            

            

                  age_range: persona.age_range,
          
        
      
        

          

            

            

                  location: persona.location,
          
        
      
        

          

            

            

                  demographic_data: persona.demographic_data,
          
        
      
        

          

            

            

                  psychographic_data: persona.psychographic_data
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def serialize_journey_for_campaign(journey)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  id: journey.id,
          
        
      
        

          

            

            

                  name: journey.name,
          
        
      
        

          

            

            

                  description: journey.description,
          
        
      
        

          

            

            

                  status: journey.status,
          
        
      
        

          

            

            

                  step_count: journey.total_steps,
          
        
      
        

          

            

            

                  performance_score: journey.latest_performance_score,
          
        
      
        

          

            

            

                  created_at: journey.created_at,
          
        
      
        

          

            

            

                  updated_at: journey.updated_at
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class Api::V1::JourneyStepsController < Api::V1::BaseController
          
        
      
        

          

            

            

              before_action :set_journey
          
        
      
        

          

            

            

              before_action :set_step, only: [:show, :update, :destroy, :reorder, :duplicate, :execute]
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/journeys/:journey_id/steps
          
        
      
        

          

            

            

              def index
          
        
      
        

          

            

            

                steps = @journey.journey_steps.includes(:transitions_from, :transitions_to)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Apply filters
          
        
      
        

          

            

            

                steps = steps.where(stage: params[:stage]) if params[:stage].present?
          
        
      
        

          

            

            

                steps = steps.where(step_type: params[:step_type]) if params[:step_type].present?
          
        
      
        

          

            

            

                steps = steps.where(status: params[:status]) if params[:status].present?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Apply sorting
          
        
      
        

          

            

            

                case params[:sort_by]
          
        
      
        

          

            

            

                when 'position'
          
        
      
        

          

            

            

                  steps = steps.order(:position)
          
        
      
        

          

            

            

                when 'stage'
          
        
      
        

          

            

            

                  steps = steps.order(:stage, :position)
          
        
      
        

          

            

            

                when 'created_at'
          
        
      
        

          

            

            

                  steps = steps.order(:created_at)
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  steps = steps.order(:position)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                paginate_and_render(steps, serializer: method(:serialize_step_summary))
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/journeys/:journey_id/steps/:id
          
        
      
        

          

            

            

              def show
          
        
      
        

          

            

            

                render_success(data: serialize_step_detail(@step))
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # POST /api/v1/journeys/:journey_id/steps
          
        
      
        

          

            

            

              def create
          
        
      
        

          

            

            

                step = @journey.journey_steps.build(step_params)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Set position if not provided
          
        
      
        

          

            

            

                if step.position.nil?
          
        
      
        

          

            

            

                  max_position = @journey.journey_steps.maximum(:position) || 0
          
        
      
        

          

            

            

                  step.position = max_position + 1
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if step.save
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: serialize_step_detail(step),
          
        
      
        

          

            

            

                    message: 'Step created successfully',
          
        
      
        

          

            

            

                    status: :created
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render_error(
          
        
      
        

          

            

            

                    message: 'Failed to create step',
          
        
      
        

          

            

            

                    errors: step.errors.as_json
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # PUT /api/v1/journeys/:journey_id/steps/:id
          
        
      
        

          

            

            

              def update
          
        
      
        

          

            

            

                if @step.update(step_params)
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: serialize_step_detail(@step),
          
        
      
        

          

            

            

                    message: 'Step updated successfully'
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render_error(
          
        
      
        

          

            

            

                    message: 'Failed to update step',
          
        
      
        

          

            

            

                    errors: @step.errors.as_json
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # DELETE /api/v1/journeys/:journey_id/steps/:id
          
        
      
        

          

            

            

              def destroy
          
        
      
        

          

            

            

                @step.destroy!
          
        
      
        

          

            

            

                render_success(message: 'Step deleted successfully')
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # PATCH /api/v1/journeys/:journey_id/steps/:id/reorder
          
        
      
        

          

            

            

              def reorder
          
        
      
        

          

            

            

                new_position = params[:position].to_i
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if new_position > 0
          
        
      
        

          

            

            

                  @step.update!(position: new_position)
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: serialize_step_detail(@step),
          
        
      
        

          

            

            

                    message: 'Step reordered successfully'
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render_error(message: 'Invalid position')
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # POST /api/v1/journeys/:journey_id/steps/:id/duplicate
          
        
      
        

          

            

            

              def duplicate
          
        
      
        

          

            

            

                begin
          
        
      
        

          

            

            

                  new_step = @step.dup
          
        
      
        

          

            

            

                  new_step.name = "#{@step.name} (Copy)"
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  # Set new position
          
        
      
        

          

            

            

                  max_position = @journey.journey_steps.maximum(:position) || 0
          
        
      
        

          

            

            

                  new_step.position = max_position + 1
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  new_step.save!
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: serialize_step_detail(new_step),
          
        
      
        

          

            

            

                    message: 'Step duplicated successfully',
          
        
      
        

          

            

            

                    status: :created
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                rescue => e
          
        
      
        

          

            

            

                  render_error(message: "Failed to duplicate step: #{e.message}")
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # POST /api/v1/journeys/:journey_id/steps/:id/execute
          
        
      
        

          

            

            

              def execute
          
        
      
        

          

            

            

                execution_params = params.permit(:user_data, metadata: {})
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                begin
          
        
      
        

          

            

            

                  # This would integrate with the journey execution engine
          
        
      
        

          

            

            

                  execution_result = execute_step(@step, execution_params)
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: execution_result,
          
        
      
        

          

            

            

                    message: 'Step executed successfully'
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                rescue => e
          
        
      
        

          

            

            

                  render_error(message: "Failed to execute step: #{e.message}")
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/journeys/:journey_id/steps/:id/transitions
          
        
      
        

          

            

            

              def transitions
          
        
      
        

          

            

            

                transitions_from = @step.transitions_from.includes(:to_step)
          
        
      
        

          

            

            

                transitions_to = @step.transitions_to.includes(:from_step)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                transitions_data = {
          
        
      
        

          

            

            

                  outgoing: transitions_from.map { |t| serialize_transition(t) },
          
        
      
        

          

            

            

                  incoming: transitions_to.map { |t| serialize_transition(t) }
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: transitions_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # POST /api/v1/journeys/:journey_id/steps/:id/transitions
          
        
      
        

          

            

            

              def create_transition
          
        
      
        

          

            

            

                transition_params = params.require(:transition).permit(:to_step_id, :condition_type, :condition_data, :weight, metadata: {})
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                to_step = @journey.journey_steps.find(transition_params[:to_step_id])
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                transition = @step.transitions_from.build(transition_params.merge(to_step: to_step))
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if transition.save
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: serialize_transition(transition),
          
        
      
        

          

            

            

                    message: 'Transition created successfully',
          
        
      
        

          

            

            

                    status: :created
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                else
          
        
      
        

          

            

            

                  render_error(
          
        
      
        

          

            

            

                    message: 'Failed to create transition',
          
        
      
        

          

            

            

                    errors: transition.errors.as_json
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              # GET /api/v1/journeys/:journey_id/steps/:id/analytics
          
        
      
        

          

            

            

              def analytics
          
        
      
        

          

            

            

                days = [params[:days].to_i, 1].max
          
        
      
        

          

            

            

                days = [days, 365].min
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Get step execution analytics
          
        
      
        

          

            

            

                executions = @step.step_executions
          
        
      
        

          

            

            

                  .where(created_at: days.days.ago..Time.current)
          
        
      
        

          

            

            

                  .includes(:journey_execution)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                analytics_data = {
          
        
      
        

          

            

            

                  execution_count: executions.count,
          
        
      
        

          

            

            

                  completion_rate: calculate_step_completion_rate(executions),
          
        
      
        

          

            

            

                  average_duration: calculate_average_duration(executions),
          
        
      
        

          

            

            

                  success_rate: calculate_step_success_rate(executions),
          
        
      
        

          

            

            

                  conversion_metrics: calculate_step_conversions(executions),
          
        
      
        

          

            

            

                  engagement_metrics: calculate_step_engagement(executions)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: analytics_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def set_journey
          
        
      
        

          

            

            

                @journey = current_user.journeys.find(params[:journey_id])
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def set_step
          
        
      
        

          

            

            

                @step = @journey.journey_steps.find(params[:id])
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def step_params
          
        
      
        

          

            

            

                params.require(:step).permit(
          
        
      
        

          

            

            

                  :name, :description, :step_type, :stage, :position, :timing,
          
        
      
        

          

            

            

                  :status, :trigger_conditions, :success_criteria,
          
        
      
        

          

            

            

                  content: {}, metadata: {}, settings: {}
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def serialize_step_summary(step)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  id: step.id,
          
        
      
        

          

            

            

                  name: step.name,
          
        
      
        

          

            

            

                  description: step.description,
          
        
      
        

          

            

            

                  step_type: step.step_type,
          
        
      
        

          

            

            

                  stage: step.stage,
          
        
      
        

          

            

            

                  position: step.position,
          
        
      
        

          

            

            

                  status: step.status,
          
        
      
        

          

            

            

                  timing: step.timing,
          
        
      
        

          

            

            

                  created_at: step.created_at,
          
        
      
        

          

            

            

                  updated_at: step.updated_at
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def serialize_step_detail(step)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  id: step.id,
          
        
      
        

          

            

            

                  journey_id: step.journey_id,
          
        
      
        

          

            

            

                  name: step.name,
          
        
      
        

          

            

            

                  description: step.description,
          
        
      
        

          

            

            

                  step_type: step.step_type,
          
        
      
        

          

            

            

                  stage: step.stage,
          
        
      
        

          

            

            

                  position: step.position,
          
        
      
        

          

            

            

                  timing: step.timing,
          
        
      
        

          

            

            

                  status: step.status,
          
        
      
        

          

            

            

                  trigger_conditions: step.trigger_conditions,
          
        
      
        

          

            

            

                  success_criteria: step.success_criteria,
          
        
      
        

          

            

            

                  content: step.content,
          
        
      
        

          

            

            

                  metadata: step.metadata,
          
        
      
        

          

            

            

                  settings: step.settings,
          
        
      
        

          

            

            

                  created_at: step.created_at,
          
        
      
        

          

            

            

                  updated_at: step.updated_at,
          
        
      
        

          

            

            

                  transitions_count: {
          
        
      
        

          

            

            

                    outgoing: step.transitions_from.count,
          
        
      
        

          

            

            

                    incoming: step.transitions_to.count
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def serialize_transition(transition)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  id: transition.id,
          
        
      
        

          

            

            

                  from_step_id: transition.from_step_id,
          
        
      
        

          

            

            

                  to_step_id: transition.to_step_id,
          
        
      
        

          

            

            

                  from_step_name: transition.from_step.name,
          
        
      
        

          

            

            

                  to_step_name: transition.to_step.name,
          
        
      
        

          

            

            

                  condition_type: transition.condition_type,
          
        
      
        

          

            

            

                  condition_data: transition.condition_data,
          
        
      
        

          

            

            

                  weight: transition.weight,
          
        
      
        

          

            

            

                  metadata: transition.metadata,
          
        
      
        

          

            

            

                  created_at: transition.created_at
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def execute_step(step, execution_params)
          
        
      
        

          

            

            

                # Placeholder for step execution logic
          
        
      
        

          

            

            

                # This would integrate with the journey execution engine
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  step_id: step.id,
          
        
      
        

          

            

            

                  execution_id: SecureRandom.uuid,
          
        
      
        

          

            

            

                  status: 'executed',
          
        
      
        

          

            

            

                  executed_at: Time.current,
          
        
      
        

          

            

            

                  result: 'success',
          
        
      
        

          

            

            

                  metadata: execution_params[:metadata] || {}
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_step_completion_rate(executions)
          
        
      
        

          

            

            

                return 0.0 if executions.empty?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                completed = executions.select { |e| e.status == 'completed' }.count
          
        
      
        

          

            

            

                (completed.to_f / executions.count * 100).round(2)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_average_duration(executions)
          
        
      
        

          

            

            

                durations = executions.filter_map do |e|
          
        
      
        

          

            

            

                  next unless e.completed_at && e.started_at
          
        
      
        

          

            

            

                  (e.completed_at - e.started_at).to_i
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                return 0 if durations.empty?
          
        
      
        

          

            

            

                (durations.sum.to_f / durations.count).round(2)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_step_success_rate(executions)
          
        
      
        

          

            

            

                return 0.0 if executions.empty?
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                successful = executions.select { |e| %w[completed success].include?(e.status) }.count
          
        
      
        

          

            

            

                (successful.to_f / executions.count * 100).round(2)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_step_conversions(executions)
          
        
      
        

          

            

            

                # Placeholder for conversion tracking
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  total_conversions: 0,
          
        
      
        

          

            

            

                  conversion_rate: 0.0,
          
        
      
        

          

            

            

                  conversion_value: 0.0
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def calculate_step_engagement(executions)
          
        
      
        

          

            

            

                # Placeholder for engagement metrics
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  engagement_score: 0.0,
          
        
      
        

          

            

            

                  interaction_count: 0,
          
        
      
        

          

            

            

                  average_time_spent: 0.0
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end
          
        
      
    
  

    

      
        

          

            

            

            class Api::V1::JourneySuggestionsController < Api::V1::BaseController
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def index
          
        
      
        

          

            

            

                suggestions = generate_suggestions_for_journey
          
        
      
        

          

            

            

                render_success(data: { suggestions: suggestions })
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def for_stage
          
        
      
        

          

            

            

                stage = params[:stage]
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                unless Journey::STAGES.include?(stage)
          
        
      
        

          

            

            

                  return render_error(message: 'Invalid stage specified', code: 'INVALID_STAGE')
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                suggestions = generate_suggestions_for_stage(stage)
          
        
      
        

          

            

            

                render_success(data: { suggestions: suggestions })
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def for_step
          
        
      
        

          

            

            

                step_data = params.permit(:type, :stage, :previous_steps => [], :journey_context => {})
          
        
      
        

          

            

            

                suggestions = generate_suggestions_for_step(step_data)
          
        
      
        

          

            

            

                render_success(data: { suggestions: suggestions })
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def bulk_suggestions
          
        
      
        

          

            

            

                request_params = params.permit(:journey_id, :count, stages: [], context: {})
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                journey = current_user.journeys.find(request_params[:journey_id]) if request_params[:journey_id]
          
        
      
        

          

            

            

                stages = request_params[:stages] || Journey::STAGES
          
        
      
        

          

            

            

                count_per_stage = [request_params[:count].to_i, 3].max
          
        
      
        

          

            

            

                count_per_stage = [count_per_stage, 10].min # Cap at 10 per stage
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                bulk_suggestions = {}
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                stages.each do |stage|
          
        
      
        

          

            

            

                  next unless Journey::STAGES.include?(stage)
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  suggestions = generate_suggestions_for_stage(stage)
          
        
      
        

          

            

            

                  bulk_suggestions[stage] = suggestions.take(count_per_stage)
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(
          
        
      
        

          

            

            

                  data: { 
          
        
      
        

          

            

            

                    bulk_suggestions: bulk_suggestions,
          
        
      
        

          

            

            

                    journey_context: journey ? serialize_journey_context(journey) : nil
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def personalized_suggestions
          
        
      
        

          

            

            

                persona_id = params[:persona_id]
          
        
      
        

          

            

            

                campaign_id = params[:campaign_id]
          
        
      
        

          

            

            

                journey_id = params[:journey_id]
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                context = build_personalization_context(persona_id, campaign_id, journey_id)
          
        
      
        

          

            

            

                suggestions = generate_personalized_suggestions(context)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(
          
        
      
        

          

            

            

                  data: { 
          
        
      
        

          

            

            

                    suggestions: suggestions,
          
        
      
        

          

            

            

                    personalization_context: context
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                )
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def create_feedback
          
        
      
        

          

            

            

                feedback_params = params.permit(:suggestion_id, :feedback_type, :rating, :comment, :journey_id, :step_id)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                begin
          
        
      
        

          

            

            

                  feedback = current_user.suggestion_feedbacks.create!(
          
        
      
        

          

            

            

                    suggestion_id: feedback_params[:suggestion_id],
          
        
      
        

          

            

            

                    feedback_type: feedback_params[:feedback_type],
          
        
      
        

          

            

            

                    rating: feedback_params[:rating],
          
        
      
        

          

            

            

                    comment: feedback_params[:comment],
          
        
      
        

          

            

            

                    journey_id: feedback_params[:journey_id],
          
        
      
        

          

            

            

                    metadata: {
          
        
      
        

          

            

            

                      step_id: feedback_params[:step_id],
          
        
      
        

          

            

            

                      created_via_api: true,
          
        
      
        

          

            

            

                      user_agent: request.user_agent
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  render_success(
          
        
      
        

          

            

            

                    data: serialize_feedback(feedback),
          
        
      
        

          

            

            

                    message: 'Feedback recorded successfully'
          
        
      
        

          

            

            

                  )
          
        
      
        

          

            

            

                rescue => e
          
        
      
        

          

            

            

                  render_error(message: "Failed to record feedback: #{e.message}")
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def feedback_analytics
          
        
      
        

          

            

            

                # Get feedback analytics for improving suggestions
          
        
      
        

          

            

            

                days = [params[:days].to_i, 30].max
          
        
      
        

          

            

            

                days = [days, 365].min
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                start_date = days.days.ago
          
        
      
        

          

            

            

                feedbacks = current_user.suggestion_feedbacks.where(created_at: start_date..)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                analytics = {
          
        
      
        

          

            

            

                  total_feedback_count: feedbacks.count,
          
        
      
        

          

            

            

                  average_rating: feedbacks.average(:rating)&.round(2) || 0,
          
        
      
        

          

            

            

                  feedback_by_type: feedbacks.group(:feedback_type).count,
          
        
      
        

          

            

            

                  rating_distribution: feedbacks.group(:rating).count,
          
        
      
        

          

            

            

                  top_suggestions: find_top_rated_suggestions(feedbacks),
          
        
      
        

          

            

            

                  improvement_areas: identify_improvement_areas(feedbacks)
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: analytics)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def suggestion_history
          
        
      
        

          

            

            

                journey_id = params[:journey_id]
          
        
      
        

          

            

            

                days = [params[:days].to_i, 30].max
          
        
      
        

          

            

            

                days = [days, 90].min
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # This would track suggestion history in a real implementation
          
        
      
        

          

            

            

                history_data = {
          
        
      
        

          

            

            

                  suggestions_generated: 0,
          
        
      
        

          

            

            

                  suggestions_used: 0,
          
        
      
        

          

            

            

                  user_satisfaction: 0.0,
          
        
      
        

          

            

            

                  popular_suggestion_types: [],
          
        
      
        

          

            

            

                  trend_analysis: {}
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(data: history_data)
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def refresh_cache
          
        
      
        

          

            

            

                # Clear and refresh suggestion caches
          
        
      
        

          

            

            

                # This would integrate with the caching system
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                render_success(message: 'Suggestion cache refreshed successfully')
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              private
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def generate_suggestions_for_journey
          
        
      
        

          

            

            

                # Generate general journey suggestions based on user context
          
        
      
        

          

            

            

                [
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: 'welcome-email-001',
          
        
      
        

          

            

            

                    type: 'step',
          
        
      
        

          

            

            

                    title: 'Welcome Email Sequence',
          
        
      
        

          

            

            

                    description: 'Start with a personalized welcome email to introduce your brand',
          
        
      
        

          

            

            

                    confidence: 0.95,
          
        
      
        

          

            

            

                    data: {
          
        
      
        

          

            

            

                      step_type: 'email_sequence',
          
        
      
        

          

            

            

                      stage: 'awareness',
          
        
      
        

          

            

            

                      timing: 'immediate',
          
        
      
        

          

            

            

                      subject: 'Welcome to [Brand Name]!',
          
        
      
        

          

            

            

                      template: 'welcome'
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  },
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: 'social-proof-002',
          
        
      
        

          

            

            

                    type: 'step',
          
        
      
        

          

            

            

                    title: 'Social Media Engagement',
          
        
      
        

          

            

            

                    description: 'Share customer testimonials on social media',
          
        
      
        

          

            

            

                    confidence: 0.88,
          
        
      
        

          

            

            

                    data: {
          
        
      
        

          

            

            

                      step_type: 'social_media',
          
        
      
        

          

            

            

                      stage: 'consideration',
          
        
      
        

          

            

            

                      timing: '3_days',
          
        
      
        

          

            

            

                      channel: 'facebook'
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  },
          
        
      
        

          

            

            

                  {
          
        
      
        

          

            

            

                    id: 'nurture-sequence-003',
          
        
      
        

          

            

            

                    type: 'step',
          
        
      
        

          

            

            

                    title: 'Educational Content Series',
          
        
      
        

          

            

            

                    description: 'Provide valuable content to nurture leads',
          
        
      
        

          

            

            

                    confidence: 0.92,
          
        
      
        

          

            

            

                    data: {
          
        
      
        

          

            

            

                      step_type: 'blog_post',
          
        
      
        

          

            

            

                      stage: 'consideration',
          
        
      
        

          

            

            

                      timing: '1_week'
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                ]
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def generate_suggestions_for_stage(stage)
          
        
      
        

          

            

            

                stage_suggestions = {
          
        
      
        

          

            

            

                  'awareness' => [
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-blog-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Educational Blog Post',
          
        
      
        

          

            

            

                      description: 'Create content that addresses common pain points',
          
        
      
        

          

            

            

                      confidence: 0.90,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'blog_post',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: 'immediate'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-social-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Social Media Campaign',
          
        
      
        

          

            

            

                      description: 'Reach new audiences through targeted social content',
          
        
      
        

          

            

            

                      confidence: 0.85,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'social_media',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: 'immediate'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-lead-magnet-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Lead Magnet',
          
        
      
        

          

            

            

                      description: 'Offer valuable resource to capture leads',
          
        
      
        

          

            

            

                      confidence: 0.93,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'lead_magnet',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: 'immediate'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  ],
          
        
      
        

          

            

            

                  'consideration' => [
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-email-sequence-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Nurture Email Sequence',
          
        
      
        

          

            

            

                      description: 'Build relationships with educational content',
          
        
      
        

          

            

            

                      confidence: 0.95,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'email_sequence',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: '1_day'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-webinar-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Educational Webinar',
          
        
      
        

          

            

            

                      description: 'Demonstrate expertise and build trust',
          
        
      
        

          

            

            

                      confidence: 0.88,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'webinar',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: '1_week'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-case-study-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Customer Case Study',
          
        
      
        

          

            

            

                      description: 'Show real results and social proof',
          
        
      
        

          

            

            

                      confidence: 0.91,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'case_study',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: '3_days'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  ],
          
        
      
        

          

            

            

                  'conversion' => [
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-sales-call-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Consultation Call',
          
        
      
        

          

            

            

                      description: 'Personal conversation to address specific needs',
          
        
      
        

          

            

            

                      confidence: 0.97,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'sales_call',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: '1_day'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-demo-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Product Demonstration',
          
        
      
        

          

            

            

                      description: 'Show how your solution solves their problems',
          
        
      
        

          

            

            

                      confidence: 0.92,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'demo',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: 'immediate'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-trial-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Free Trial Offer',
          
        
      
        

          

            

            

                      description: 'Let prospects experience your product risk-free',
          
        
      
        

          

            

            

                      confidence: 0.89,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'trial_offer',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: 'immediate'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  ],
          
        
      
        

          

            

            

                  'retention' => [
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-onboarding-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Customer Onboarding',
          
        
      
        

          

            

            

                      description: 'Ensure new customers get maximum value',
          
        
      
        

          

            

            

                      confidence: 0.98,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'onboarding',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: 'immediate'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-newsletter-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Regular Newsletter',
          
        
      
        

          

            

            

                      description: 'Keep customers engaged with updates and tips',
          
        
      
        

          

            

            

                      confidence: 0.86,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'newsletter',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: '1_week'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    },
          
        
      
        

          

            

            

                    {
          
        
      
        

          

            

            

                      id: "#{stage}-feedback-001",
          
        
      
        

          

            

            

                      type: 'step',
          
        
      
        

          

            

            

                      title: 'Feedback Survey',
          
        
      
        

          

            

            

                      description: 'Gather insights to improve customer experience',
          
        
      
        

          

            

            

                      confidence: 0.82,
          
        
      
        

          

            

            

                      data: {
          
        
      
        

          

            

            

                        step_type: 'feedback_survey',
          
        
      
        

          

            

            

                        stage: stage,
          
        
      
        

          

            

            

                        timing: '2_weeks'
          
        
      
        

          

            

            

                      }
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  ]
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                stage_suggestions[stage] || []
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def generate_suggestions_for_step(step_data)
          
        
      
        

          

            

            

                suggestions = []
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Analyze previous steps to suggest next logical steps
          
        
      
        

          

            

            

                previous_steps = step_data[:previous_steps] || []
          
        
      
        

          

            

            

                current_stage = step_data[:stage]
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Logic to suggest next steps based on current step type and stage
          
        
      
        

          

            

            

                case step_data[:type]
          
        
      
        

          

            

            

                when 'lead_magnet'
          
        
      
        

          

            

            

                  suggestions << {
          
        
      
        

          

            

            

                    id: 'follow-up-email-001',
          
        
      
        

          

            

            

                    type: 'connection',
          
        
      
        

          

            

            

                    title: 'Follow-up Email',
          
        
      
        

          

            

            

                    description: 'Send a thank you email with additional resources',
          
        
      
        

          

            

            

                    confidence: 0.95,
          
        
      
        

          

            

            

                    data: {
          
        
      
        

          

            

            

                      step_type: 'email_sequence',
          
        
      
        

          

            

            

                      stage: 'consideration',
          
        
      
        

          

            

            

                      timing: '1_day',
          
        
      
        

          

            

            

                      subject: 'Thank you for downloading [Resource Name]'
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                when 'email_sequence'
          
        
      
        

          

            

            

                  suggestions << {
          
        
      
        

          

            

            

                    id: 'social-engagement-001',
          
        
      
        

          

            

            

                    type: 'connection',
          
        
      
        

          

            

            

                    title: 'Social Media Follow-up',
          
        
      
        

          

            

            

                    description: 'Engage prospects on social media',
          
        
      
        

          

            

            

                    confidence: 0.85,
          
        
      
        

          

            

            

                    data: {
          
        
      
        

          

            

            

                      step_type: 'social_media',
          
        
      
        

          

            

            

                      stage: current_stage,
          
        
      
        

          

            

            

                      timing: '2_days'
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                when 'webinar'
          
        
      
        

          

            

            

                  suggestions << {
          
        
      
        

          

            

            

                    id: 'sales-call-follow-001',
          
        
      
        

          

            

            

                    type: 'connection',
          
        
      
        

          

            

            

                    title: 'Sales Call',
          
        
      
        

          

            

            

                    description: 'Schedule a call with interested attendees',
          
        
      
        

          

            

            

                    confidence: 0.92,
          
        
      
        

          

            

            

                    data: {
          
        
      
        

          

            

            

                      step_type: 'sales_call',
          
        
      
        

          

            

            

                      stage: 'conversion',
          
        
      
        

          

            

            

                      timing: '1_day'
          
        
      
        

          

            

            

                    }
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                suggestions
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def serialize_journey_context(journey)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  id: journey.id,
          
        
      
        

          

            

            

                  name: journey.name,
          
        
      
        

          

            

            

                  campaign_type: journey.campaign_type,
          
        
      
        

          

            

            

                  target_audience: journey.target_audience,
          
        
      
        

          

            

            

                  step_count: journey.total_steps,
          
        
      
        

          

            

            

                  stages_used: journey.steps_by_stage.keys
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def build_personalization_context(persona_id, campaign_id, journey_id)
          
        
      
        

          

            

            

                context = {}
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if persona_id.present?
          
        
      
        

          

            

            

                  persona = current_user.personas.find_by(id: persona_id)
          
        
      
        

          

            

            

                  context[:persona] = persona.to_campaign_context if persona
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if campaign_id.present?
          
        
      
        

          

            

            

                  campaign = current_user.campaigns.find_by(id: campaign_id)
          
        
      
        

          

            

            

                  context[:campaign] = campaign.to_analytics_context if campaign
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if journey_id.present?
          
        
      
        

          

            

            

                  journey = current_user.journeys.find_by(id: journey_id)
          
        
      
        

          

            

            

                  context[:journey] = serialize_journey_context(journey) if journey
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                context
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def generate_personalized_suggestions(context)
          
        
      
        

          

            

            

                # Enhanced suggestions based on persona, campaign, and journey context
          
        
      
        

          

            

            

                base_suggestions = generate_suggestions_for_journey
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                # Customize suggestions based on context
          
        
      
        

          

            

            

                if context[:persona]
          
        
      
        

          

            

            

                  base_suggestions = filter_suggestions_by_persona(base_suggestions, context[:persona])
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                if context[:campaign]
          
        
      
        

          

            

            

                  base_suggestions = enhance_suggestions_with_campaign_data(base_suggestions, context[:campaign])
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                base_suggestions
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def filter_suggestions_by_persona(suggestions, persona_context)
          
        
      
        

          

            

            

                # Filter and prioritize suggestions based on persona characteristics
          
        
      
        

          

            

            

                suggestions.map do |suggestion|
          
        
      
        

          

            

            

                  # Adjust confidence scores based on persona fit
          
        
      
        

          

            

            

                  if persona_context[:age_range] == '25-35' && suggestion[:data][:step_type] == 'social_media'
          
        
      
        

          

            

            

                    suggestion[:confidence] = [suggestion[:confidence] * 1.1, 1.0].min
          
        
      
        

          

            

            

                  end
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  suggestion
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def enhance_suggestions_with_campaign_data(suggestions, campaign_context)
          
        
      
        

          

            

            

                # Enhance suggestions with campaign-specific data
          
        
      
        

          

            

            

                suggestions.map do |suggestion|
          
        
      
        

          

            

            

                  suggestion[:data][:campaign_context] = {
          
        
      
        

          

            

            

                    campaign_type: campaign_context[:campaign_type],
          
        
      
        

          

            

            

                    industry: campaign_context[:industry]
          
        
      
        

          

            

            

                  }
          
        
      
        

          

            

            

                  
          
        
      
        

          

            

            

                  suggestion
          
        
      
        

          

            

            

                end
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def serialize_feedback(feedback)
          
        
      
        

          

            

            

                {
          
        
      
        

          

            

            

                  id: feedback.id,
          
        
      
        

          

            

            

                  suggestion_id: feedback.suggestion_id,
          
        
      
        

          

            

            

                  feedback_type: feedback.feedback_type,
          
        
      
        

          

            

            

                  rating: feedback.rating,
          
        
      
        

          

            

            

                  comment: feedback.comment,
          
        
      
        

          

            

            

                  journey_id: feedback.journey_id,
          
        
      
        

          

            

            

                  created_at: feedback.created_at
          
        
      
        

          

            

            

                }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def find_top_rated_suggestions(feedbacks)
          
        
      
        

          

            

            

                feedbacks.group(:suggestion_id)
          
        
      
        

          

            

            

                  .average(:rating)
          
        
      
        

          

            

            

                  .sort_by { |_, rating| -rating }
          
        
      
        

          

            

            

                  .first(5)
          
        
      
        

          

            

            

                  .map { |suggestion_id, rating| { suggestion_id: suggestion_id, rating: rating.round(2) } }
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

              
          
        
      
        

          

            

            

              def identify_improvement_areas(feedbacks)
          
        
      
        

          

            

            

                low_rated = feedbacks.where('rating < ?', 3)
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                areas = []
          
        
      
        

          

            

            

                areas << 'Suggestion relevance' if low_rated.where(feedback_type: 'relevance').count > low_rated.count * 0.3
          
        
      
        

          

            

            

                areas << 'Suggestion quality' if low_rated.where(feedback_type: 'quality').count > low_rated.count * 0.3
          
        
      
        

          

            

            

                areas << 'Implementation difficulty' if low_rated.where(feedback_type: 'difficulty').count > low_rated.count * 0.3
          
        
      
        

          

            

            

                
          
        
      
        

          

            

            

                areas
          
        
      
        

          

            

            

              end
          
        
      
        

          

            

            

            end